package org.cn.zhaozhx.services;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.util.zip.CRC32;
import java.util.zip.CheckedInputStream;

/*
 * 新浪微博加密算法
 */
public class SHA1 {
    private final static int[] abcde = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 };
    // 摘要数据存储数组 
    private static int[] digestInt = new int[5];
    // 计算过程中的临时数据存储数组 
    private static int[] tmpData = new int[80];
    
    // 计算sha-1摘要 
    private static int process_input_bytes(byte[] bytedata) {
        // 初试化常量 
        System.arraycopy(abcde, 0, digestInt, 0, abcde.length);
        // 格式化输入字节数组，补10及长度数据 
        byte[] newbyte = byteArrayFormatData(bytedata);
        // 获取数据摘要计算的数据单元个数 
        int MCount = newbyte.length / 64;
        // 循环对每个数据单元进行摘要计算 
        for (int pos = 0; pos < MCount; pos++) {
            // 将每个单元的数据转换成16个整型数据，并保存到tmpData的前16个数组元素中 
            for (int j = 0; j < 16; j++) {
                tmpData[j] = byteArrayToInt(newbyte, (pos * 64) + (j * 4));
            }
            // 摘要计算函数 
            encrypt();
        }
        return 20;
    }
    
    // 格式化输入字节数组格式 
    private static byte[] byteArrayFormatData(byte[] bytedata) {
        // 补0数量 
        int zeros = 0;
        // 补位后总位数 
        int size = 0;
        // 原始数据长度 
        int n = bytedata.length;
        // 模64后的剩余位数 
        int m = n % 64;
        // 计算添加0的个数以及添加10后的总长度 
        if (m < 56) {
            zeros = 55 - m;
            size = n - m + 64;
        } else if (m == 56) {
            zeros = 63;
            size = n + 8 + 64;
        } else {
            zeros = 63 - m + 56;
            size = (n + 64) - m + 64;
        }
        // 补位后生成的新数组内容 
        byte[] newbyte = new byte[size];
        // 复制数组的前面部分 
        System.arraycopy(bytedata, 0, newbyte, 0, n);
        // 获得数组Append数据元素的位置 
        int l = n;
        // 补1操作 
        newbyte[l++] = (byte) 0x80;
        // 补0操作 
        for (int i = 0; i < zeros; i++) {
            newbyte[l++] = (byte) 0x00;
        }
        // 计算数据长度，补数据长度位共8字节，长整型 
        long N = (long) n * 8;
        byte h8 = (byte) (N & 0xFF);
        byte h7 = (byte) ((N >> 8) & 0xFF);
        byte h6 = (byte) ((N >> 16) & 0xFF);
        byte h5 = (byte) ((N >> 24) & 0xFF);
        byte h4 = (byte) ((N >> 32) & 0xFF);
        byte h3 = (byte) ((N >> 40) & 0xFF);
        byte h2 = (byte) ((N >> 48) & 0xFF);
        byte h1 = (byte) (N >> 56);
        newbyte[l++] = h1;
        newbyte[l++] = h2;
        newbyte[l++] = h3;
        newbyte[l++] = h4;
        newbyte[l++] = h5;
        newbyte[l++] = h6;
        newbyte[l++] = h7;
        newbyte[l++] = h8;
        return newbyte;
    }
    
    private static int f1(int x, int y, int z) {
        return (x & y) | (~x & z);
    }
    
    private static int f2(int x, int y, int z) {
        return x ^ y ^ z;
    }
    
    private static int f3(int x, int y, int z) {
        return (x & y) | (x & z) | (y & z);
    }
    
    private static int f4(int x, int y) {
        return (x << y) | x >>> (32 - y);
    }
    
    // 单元摘要计算函数 
    private static void encrypt() {
        for (int i = 16; i <= 79; i++) {
            tmpData[i] = f4(tmpData[i - 3] ^ tmpData[i - 8] ^ tmpData[i - 14] ^ tmpData[i - 16], 1);
        }
        int[] tmpabcde = new int[5];
        for (int i1 = 0; i1 < tmpabcde.length; i1++) {
            tmpabcde[i1] = digestInt[i1];
        }
        for (int j = 0; j <= 19; j++) {
            int tmp = f4(tmpabcde[0], 5) + f1(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4] + tmpData[j]
                    + 0x5a827999;
            tmpabcde[4] = tmpabcde[3];
            tmpabcde[3] = tmpabcde[2];
            tmpabcde[2] = f4(tmpabcde[1], 30);
            tmpabcde[1] = tmpabcde[0];
            tmpabcde[0] = tmp;
        }
        for (int k = 20; k <= 39; k++) {
            int tmp = f4(tmpabcde[0], 5) + f2(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4] + tmpData[k]
                    + 0x6ed9eba1;
            tmpabcde[4] = tmpabcde[3];
            tmpabcde[3] = tmpabcde[2];
            tmpabcde[2] = f4(tmpabcde[1], 30);
            tmpabcde[1] = tmpabcde[0];
            tmpabcde[0] = tmp;
        }
        for (int l = 40; l <= 59; l++) {
            int tmp = f4(tmpabcde[0], 5) + f3(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4] + tmpData[l]
                    + 0x8f1bbcdc;
            tmpabcde[4] = tmpabcde[3];
            tmpabcde[3] = tmpabcde[2];
            tmpabcde[2] = f4(tmpabcde[1], 30);
            tmpabcde[1] = tmpabcde[0];
            tmpabcde[0] = tmp;
        }
        for (int m = 60; m <= 79; m++) {
            int tmp = f4(tmpabcde[0], 5) + f2(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4] + tmpData[m]
                    + 0xca62c1d6;
            tmpabcde[4] = tmpabcde[3];
            tmpabcde[3] = tmpabcde[2];
            tmpabcde[2] = f4(tmpabcde[1], 30);
            tmpabcde[1] = tmpabcde[0];
            tmpabcde[0] = tmp;
        }
        for (int i2 = 0; i2 < tmpabcde.length; i2++) {
            digestInt[i2] = digestInt[i2] + tmpabcde[i2];
        }
        for (int n = 0; n < tmpData.length; n++) {
            tmpData[n] = 0;
        }
    }
    
    // 4字节数组转换为整数 
    private static int byteArrayToInt(byte[] bytedata, int i) {
        return ((bytedata[i] & 0xff) << 24) | ((bytedata[i + 1] & 0xff) << 16) | ((bytedata[i + 2] & 0xff) << 8)
                | (bytedata[i + 3] & 0xff);
    }
    
    // 整数转换为4字节数组 
    private static void intToByteArray(int intValue, byte[] byteData, int i) {
        byteData[i] = (byte) (intValue >>> 24);
        byteData[i + 1] = (byte) (intValue >>> 16);
        byteData[i + 2] = (byte) (intValue >>> 8);
        byteData[i + 3] = (byte) intValue;
    }
    
    // 将字节转换为十六进制字符串 
    private static String byteToHexString(byte ib) {
        char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
        char[] ob = new char[2];
        ob[0] = Digit[(ib >>> 4) & 0X0F];
        ob[1] = Digit[ib & 0X0F];
        String s = new String(ob);
        return s;
    }
    
    // 将字节数组转换为十六进制字符串 
    private static String byteArrayToHexString(byte[] bytearray) {
        String strDigest = "";
        for (int i = 0; i < bytearray.length; i++) {
            strDigest += byteToHexString(bytearray[i]);
        }
        return strDigest;
    }
    
    // 计算sha-1摘要，返回相应的字节数组 
    public static byte[] getDigestOfBytes(byte[] byteData) {
        process_input_bytes(byteData);
        byte[] digest = new byte[20];
        for (int i = 0; i < digestInt.length; i++) {
            intToByteArray(digestInt[i], digest, i * 4);
        }
        return digest;
    }
    
    // 计算sha-1摘要，返回相应的十六进制字符串 
    public static String getDigestOfString(byte[] byteData) {
        return byteArrayToHexString(getDigestOfBytes(byteData));
    }
    
    public static String getDigestOfFile(String file_path) {
        try {
            int len;
            byte data[];
            String code;
            FileInputStream in = new FileInputStream(new File(file_path));
            len = in.available();
            System.out.println(len);
            data = new byte[len];
            in.read(data);
            //System.out.println(data.toString()); 
            code = getDigestOfString(data);
            return code;
        } catch (Exception e) {
            System.out.println(e);
            return "f";
        }
    }
    
    public static String getDigestOfFile1(String file_path) {
        MessageDigest messagedigest;
        FileInputStream in = null;
        try {
            in = new FileInputStream(new File(file_path));
            messagedigest = MessageDigest.getInstance("SHA-1");
            byte[] buffer = new byte[1024 * 1024 * 10];
            int len = 0;
            
            while ((len = in.read(buffer)) > 0) {
                //该对象通过使用 update（）方法处理数据  
                messagedigest.update(buffer, 0, len);
            }
            
            return byte2hex(messagedigest.digest());
        } catch (Exception e) {
            System.out.println(e);
            return "f";
        } finally {
            if (null != in) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
    }
    
    //二行制转字符串
    public static String byte2hex(byte[] b) {
        String hs = "";
        String stmp = "";
        for (int n = 0; n < b.length; n++) {
            stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
            if (stmp.length() == 1)
                hs = hs + "0" + stmp;
            else
                hs = hs + stmp;
            //            if (n < b.length - 1)
            //                hs = hs;
        }
        return hs.toUpperCase();
    }
    
    /**
     * 获取单个文件的MD5值！
     * @param file
     * @return
     */
    public static String getFileMD5(File file) {
        if (!file.isFile()) {
            return null;
        }
        MessageDigest digest = null;
        FileInputStream in = null;
        byte buffer[] = new byte[1024];
        int len;
        try {
            digest = MessageDigest.getInstance("MD5");
            in = new FileInputStream(file);
            while ((len = in.read(buffer, 0, 1024)) != -1) {
                digest.update(buffer, 0, len);
            }
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        BigInteger bigInt = new BigInteger(1, digest.digest());
        return bigInt.toString(16).toUpperCase();
    }
    
    public static String getFileCRCCode(File file) throws Exception {
        
        FileInputStream fileinputstream = new FileInputStream(file);
        CRC32 crc32 = new CRC32();
        for (CheckedInputStream checkedinputstream = new CheckedInputStream(fileinputstream, crc32); checkedinputstream
                .read() != -1;) {
        }
        return Long.toHexString(crc32.getValue());
        
    }
    
    public static String getFileCrc(String filePath) throws Exception {
        FileInputStream inStream = null;
        BufferedInputStream in = null;
        CRC32 crc32 = new CRC32();
        inStream = new FileInputStream(filePath);
        in = new BufferedInputStream(inStream, 1024 * 1024 * 10);
        
        for (int i; (i = in.read()) != -1;) {
            crc32.update(i);
        }
        
        if (inStream != null)
            inStream.close();
        if (in != null)
            in.close();
        return Long.toHexString(crc32.getValue());
    }
    
    public static void main(String[] args) {
        //        String data = "ACDE123456";
        //        System.out.println(data);
        //        new SHA1();
        String digest1 = SHA1.getDigestOfFile1("/Users/zhaozhenxing/Downloads/video/n0646.wmv");
        System.out.println(digest1);
        //        System.out.println("14703CFB8D56B8A5B4E44E2B20956B29598A8342");
        //
        //        System.out.println(getFileMD5(new File("C:/QQDownload/qagsd.mp4")));
        //        System.out.println("A6315F3D93ECAFD5BE57C728216C7FE5");
        
        //        try {
        //            System.out.println(getFileCrc("C:/QQDownload/qagsd.mp4"));
        //            System.out.println("1D86F9F7");
        //        } catch (Exception e) {
        //            e.printStackTrace();
        //        }
    }
    
}
